Object modeling for exploring large data sets

ABSTRACT

An object model is used to facilitate performing financial analysis and that includes certain zero-order objects or building blocks that lend themselves particularly well to doing financial analysis. The object model comprises a universe of data items, relationships between the data items, higher-order objects generated based on one or more data items in the universe, higher-order objects generated based on other objects, and auxiliary entities related to the universe of data items.

FIELD OF THE DISCLOSURE

The present disclosure generally relates to techniques for exploringlarge data sets, for example, as related to market instruments.

BACKGROUND

The approaches described in this section are approaches that could bepursued, but not necessarily approaches that have been previouslyconceived or pursued. Therefore, unless otherwise indicated, it shouldnot be assumed that any of the approaches described in this sectionqualify as prior art merely by virtue of their inclusion in thissection.

Data processing systems can be programmed to facilitate analysis of auniverse of data items. A universe of data items refers to a largecollection of data items. An example of such a universe may be a largecollection of market instruments. In many instances, the amount of rawdata about data items can be massive and dynamically increasing all thetime. Under some approaches, an analyst relies on empirical knowledgeand cumbersome spreadsheets to analyze markets and instruments. Undersome other approaches, markets and instruments are modeled asmulti-variable stochastic, predictive systems. In all these approaches,however, what has been captured is often over-simplified and relativelystatic. These approaches cannot keep up with new variable and new trendsappearing in the markets, and therefore can hardly yield reliableinsights for future performance of the markets and instruments. Theseshortcomings are made worse, as these approaches typically providelittle support for a user to flexibly model the markets, to promptlyreact to new trends, and to timely test new hypotheses.

SUMMARY

The present disclosure is directed to a programmatic object model thatfacilitates analysis of universes of data items.

A first claim of the disclosure is an object model that facilitatesperforming financial analysis and that includes certain zero-orderobjects or building blocks that lend themselves particularly well todoing financial analysis. The object model comprises a universe of dataitems, relationships between the data items, higher-order objectsgenerated based on one or more data items in the universe, higher-orderobjects generated based on other objects, and auxiliary entities relatedto the universe of data items.

A second claim is that some of the building blocks are “zero-order”, inthat they cannot be decomposed into other building blocks. Examples ofzero-order building blocks are time series, metrics, and financialinstruments. A time series is an object that represents time-dependentinformation. A metric building block represents a type of datatransformation; for example, a metric defines a function that receivesan instrument as input and produces a time series as output. A financialinstrument building block represents any market entity that is traded orotherwise of interest, such as an equity, a currency, or a bond.

A third claim is that some of the building blocks can be decomposed intoother building blocks. Examples include a date set, index, portfolio,strategy, instrument group, and regression. For example, a date setcomprises time values that satisfy one or more selection criteria; aninstrument group comprises one or more instruments selected from auniverse of instruments using a filter chain; an index indicates acollective value of one or more instruments; a regression transforms oneor more first time series into a predicted time series and compares thepredicted time series with a second time series; a portfolio compriseszero or more time series each of which represents an instrument, aparticular date set, and one or more trades that refer to timesrepresented in the particular date set; a strategy comprises a date setthat represents a time period and a statement block that can be executedto determines one or more trades of the instrument.

Additional claims of the disclosure relate to how the foregoinghigher-order building blocks can be decomposed into the zero-orderbuilding blocks. For example, an index comprises an instrument group anda metric and a date set; an instrument group comprises filters; and afilter can be a set of instruments and a metric.

In embodiments where data items are instruments (in equity, currency andbonds), zero-order objects may refer to instruments, economic indexes,time series and meta data associated with instruments, and otherinformation that are cataloged and stored in a database for the purposeof being analyzed by the data analysis system.

Other embodiments may comprise a system and one or more machine-readablestorage media operable to provide the foregoing graphical user interfaceand/or to perform or cause the performance of the foregoingcomputer-implemented methods.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an example data analysis system for exploring auniverse of data items.

FIG. 2A illustrates an example graphical user interface related to adate set.

FIG. 2B illustrates an example graphical user interface related to aninstrument group.

FIG. 2C illustrates an example graphical user interface related to astrategy.

FIG. 2D illustrates an example graphical user interface related to aregression.

FIG. 2E illustrates an example graphical user interface related to anindex.

FIG. 2F illustrates an example graphical user interface related to acustom metric.

FIG. 2G illustrates an example graphical user interface related toselecting a custom metric.

FIG. 2H illustrates an example graphical user interface related todisplaying results involving a custom metric.

FIG. 3 illustrates an example process flow.

FIG. 4 illustrates a computer system with which an embodiment may beimplemented.

DESCRIPTION OF EXAMPLE EMBODIMENTS

In the following description, for the purposes of explanation, numerousspecific details are set forth in order to provide a thoroughunderstanding of the present invention. It will be apparent, however,that the present invention may be practiced without these specificdetails. In other instances, well-known structures and devices are shownin block diagram form in order to avoid unnecessarily obscuring thepresent invention.

1 Glossary of Terms

In this disclosure the following terms have the following meanings:

Data item: a zero-order object that can be described by a number ofproperties and/or metrics.

Higher-order objects: objects that can be immediately built on top ofzero-order objects such as instruments, while the term “higher-orderobjects” refers to objects that can be built directly or indirectly ontop of zero-order objects such as instruments.

Metric: a type of transformation. The metric performs the type oftransformation specified, e.g., using the instrument as input, andproduces the time series. In some embodiments, the identifier for theobject and the token for the type of transformation are separated by asuitable delimiter such as a period.

Object model: a model that comprises a universe of data items,relationships between the data items, higher-order objects generatedbased on one or more data items in the universe, higher-order objectsgenerated based on other objects, and auxiliary entities related to theuniverse of data items.

Ontological relationships: structural relationships existing amongzero-order objects (such as economic indexes, instruments, etc.). Theinstruments can be classified based on ontological relationships,thereby forming a hierarchy on which the object model can be furtherbuilt. In some embodiments, this hierarchy may comprise one or moreeconomic indexes, which is not specifically tied to an instrument.

Time series: a type of objects which are used in the object model torepresent time-dependent information.

Universe of data items: a large collection of data items, typicallyeverything known to a particular system.

Zero-order objects: leaf nodes in the object model. In embodiments wheredata items are instruments (in equity, currency and bonds), zero-orderobjects may refer to instruments, economic indexes, time series and metadata associated with instruments, and other information that arecataloged and stored in a database for the purpose of being analyzed bythe data analysis system.

2 Example Data Analysis System

FIG. 1 illustrates an example data analysis system for exploring auniverse of data items. Data analysis system 100 comprises applicationserver 102 and one or more clients, such as client 120.

In the embodiment illustrated in FIG. 1, client 120, which may beimplemented by one or more first physical computing devices, iscommunicatively connected to application server 102, which may beimplemented by one or more second physical computing devices, over anetwork. In some embodiments, each such physical computing device may beimplemented as a separate computer system as shown in FIG. 4. Forexample, client 120 may be implemented in a computer system as a set ofprogram instructions recorded on a machine-readable storage medium,while application server 102 may be implemented in a different computersystem. Client 120 comprises graphical user interface (GUI) logic 122.GUI logic 122 may be a set of program instructions which, when executedby one or more processors of the computer system, are operable toreceive user input and to display a graphical representation of one ormore graphic constructs related to exploring a universe of data itemsusing the approaches herein. GUI logic 122 may be operable to receiveuser input from, and display the graphic constructs to, a graphical userinterface that is provided on display 124 by the computer system onwhich client 120 executes.

In some embodiments, GUI logic 122 is omitted. For example, in oneembodiment, client 120 may comprise an application program or processthat issues one or more function calls or application programminginterface (API) calls to application server 102 to obtain informationresulting from, to provide input to, and to execute along withapplication server 102, the processes or one or more steps thereof asdescribed herein. For example, client 120 may request and obtain arepresentation of zero-order objects such as instruments, higher-orderobjects such as date sets, indexes, instrument groups, etc.,higher-order objects, and other constructs as described herein using aprogrammatic interface, and then the client may use, process, log,store, or otherwise interact with the received data according to locallogic. Client 120 may also interact with application server 102 toprovide input, definition, editing instructions, expressions related toone or more objects or constructs as described herein using aprogrammatic interface, and then the application server 102 may use,process, log, store, or otherwise interact with the received inputaccording to application server logic.

Application server 102 may be implemented as a special-purpose computersystem having the logical elements shown in FIG. 1. In an embodiment,the logical elements may comprise program instructions recorded on oneor more machine-readable storage media. Alternatively, the logicalelements may be implemented in hardware, firmware, or a combination.

When executed by one or more processors of the computer system, logic inapplication server 102 is operable to explore the universe of data itemsaccording to the techniques described herein. In one embodiment,application server 102 may be implemented in a Java Virtual Machine(JVM) that is executing in a distributed or non-distributed computersystem. In other embodiments, application server 102 may be implementedas a combination of programming instructions written in any programminglanguage (e.g. C++ or Visual Basic) and hardware components (e.g.memory, CPU time) that have been allocated for executing the programinstructions.

In an embodiment, application server 102 comprises repository accesslogic 110 and data exploring logic 104. Repository access logic 110 maycomprise a set of program instructions which, when executed by one ormore processors, are operable to access and retrieve data from datarepository 112. For example, repository access logic 110 may be adatabase client or an Open Database Connectivity (ODBC) client thatsupports calls to a database server that manages data repository 112.Data repository 112 may be any type of structured storage for storingdata including, but not limited to, relational or object-orienteddatabases, data warehouses, directories, data files, and any otherstructured data storage.

In the embodiment illustrated in FIG. 1, data exploring logic 104comprises input receiver 106 and evaluation module 108. Data exploringlogic 104 may be object-oriented logic. As used herein, the universe ofdata items can be accessed and/or operated by the data exploring logic104 to create, modify, delete, and store the data generated or used bydata analysis system 100.

In an embodiment, input receiver 106 is a set of program instructionswhich, when executed by one or more processors, are operable to receiveinput from a client.

Evaluation module 108 is a set of program instructions that implementlogic to create, modify, delete and store objects that are associatedwith the universe of data items, evaluate these objects when instructedto do so by data analysis system 100, provide the evaluation results toa client. Evaluation results of one or more objects may also be renderedby GUI logic 122 on display 120.

3 Examples of Zero-Order Objects

3.1 Instruments

An instrument is an object that represents any market traded financialentity or product of interest, such as a stock (equity), bond, currency,or fund.

3.2 Metrics

A metric is a transformation (or function) that receives one type ofdata (e.g., an object such as an instrument) and returns another type(e.g., another object such as a time series). A metric may perform anyform of specified processing, specified computation, related operationssuch as database queries, network communications and data storing. Forexample, a metric may receive a particular instrument as input andreturn a time series of the particular instrument's volume. A metric mayalso receive one time series for an instrument and return the value ofthe instrument on a given day. A metric may optionally receiveparameters at runtime that influence the execution of logic implementedin the metric. An example of a parameter that can be inputted into ametric to influence the execution of a metric may be a number of days toshow a moving average price for MSFT where the metric calculates themoving average price.

Objects that are of a higher order than a zero order can be built usingmetrics. The input objects and the output objects can be zero-order orhigher-order in any combination.

The data changes over time. Therefore, if a metric is evaluated at twodifferent times, it may produce different outputs. Alternatively, outputobjects from one or more of these metrics may be pre-computed/evaluatedand stored/cached beforehand. In some embodiments, parameters may beprovided to a metric to specify whether a cached object of a metricshould be used as input, or whether the output of a metric should becached or stored.

3.3 Time Series

A time series is a programmatic object that represents time-dependentinformation in any of several forms, including a series of discretedates or a sequence of time-related values. Where an object modelcontains a large amount of time-dependent information, many time seriesmay be created in the process of evaluating objects in the object model.For example, an instrument may have a trading history that indicates itsvalues over a period of time. From this trading history (e.g., rawtrading data), one or more time series may be created to representtime-dependent information, in any desired resolution (for example, in atime scale of years, months, weeks, days, hours, minutes, seconds).

In some embodiments, a time series may comprise a set of numeric valuesand a separate set of time values, wherein each numeric value has acorresponding time value in the set of time values. Each such numericvalue represents a value of a certain entity at each corresponding timevalue in the set of time values. For example, a time series may be usedto represent market values of an instrument. The above-mentioned “valueof a certain entity” may be a particular market value at the closing ofa trading day. In this example, the time series may comprise a set oflong or double values, each of which represents a market value at theclosing of a corresponding day as indicated by a time value in aseparate set of time values. The time series further comprises theseparate set of time values representing the closings of allcorresponding days, for which market values of the instruments areincluded in the set of long or double values.

A time series may also be used to represent values of an entity for timevalues that meet certain criteria. For example, a time series may beused to represent market values for an instrument when the instrument istraded to higher prices, when the instrument is traded to lower prices,when the volatility of the instrument exceeds a certain limit, when thevolatility of the instrument stays below a certain limit, or aderivative of other time series. Furthermore, the values of an entityare not limited to market values of an instrument. For example, thevalues of an entity, as represented by a time series, may compriseanalytical values of historical volatility of two instruments.

In some embodiments, a time series associated with an instrument may beaccessed by an expression containing an identifier (e.g., the identifier“GOOG” to indicate the equity instrument for Google, Inc.) for anotherobject such as an instrument and a token (e.g., a textual name such as“HVOL” representing historical volatility of an instrument) for a typeof transformation. In the present example where the time series isaccessed by the expression “GOOG.HVOL”, the metric identified by thetoken (e.g., “HVOL”) receives the identifier for the instrument (e.g.,“GOOG”) as input and transforms raw trading data of the instrument(i.e., “GOOG”) into a time series as an output object. This time series,for example, may represent time-dependent information of volatility ofthe instrument “GOOG” in all recorded trading days.

A time series such as described above may be further transformed alongwith other parameters into another output object.

A time series can not only represent time-dependent information forzero-order objects such as instruments, but may also representtime-dependent information for any higher-order objects in the objectmodel.

In some embodiments, a time series may be used to representtime-dependent information that is not related to another object. Forexample, a set of time values from a calendar, e.g., all week days, allwork days, all Mondays, or the second days of months, may be transformedby a metric into a time series. Such a time series may be viewed as anobject per se as it is independent of another object such as aninstrument. In some embodiments, the time series may be accessed withina global scope, by any other objects, without naming any other objectsuch as an instrument. In some embodiments, a time series may comprise aset of time values (e.g., all Mondays) without including a separate setof numeric values representing values of an entity that may beassociated with another object such as an instrument.

In some embodiments, time series may be pre-computed (evaluated) andstored/cached.

4 Example Higher-Order Objects

4.1 Date Set

A date set comprises a set of time values that satisfy one or moreselection criteria. As used herein, the term “time value” may includedate and/or time of day information at various resolutions, for example,from multiple years to sub-seconds. For example, a date set may be alltrading days when the “GOOG” stock trades up. A date set may also havean explicit start time value for the set, for example, January 1, 2006;thus, the date set excludes all time values that are before the explicitstart time value. Similarly, a date set may also have an explicit endtime value; thus, the date set excludes all time values that are afterthe explicit end time value.

A date set may also take an implicit start time value, where an explicitstart time value is not specified. For example, a date set thatcomprises all days when the “GOOG” stock trades up may have an implicitstart time value when the “GOOG” stock was first publicly traded.Similarly, a date set may also take an implicit end time value, where anexplicit end time value is not specified. For example, a date set thatcomprises all days when the “ENE” stock was available for trades mayhave an implicit end time value when the “ENE” stock was terminated frompublic trading from the New York Stock Exchange.

One of several object creation mechanisms may be used to createhigher-order objects such as date sets. One object creation mechanism isa metric. This metric may take a first input that specifies a timeseries. This time series is generally a set of date/value pairs. Thedate set metric also may take a second input that specifies one or morecriteria. For example, the one or more criteria as specified in thesecond input may specify a range. The resulting date set will thencontain all the dates as indicated by the time series that are withinthe specified range.

Another object creation mechanism to create a higher-order object suchas a date set is to directly use a programming language such as JAVA.The user may supply programming language code to the system 100, whichmay be compiled, interpreted or otherwise executed by the system 100 tocreate a date set. Extension mechanisms such as Java reflection may beused to add code segments or objects to the system so that the objectcreation mechanisms can be dynamically extended.

Yet another object creation mechanism to create a higher-order objectsuch as a date set is to interact with a user interface. For example,tools or widgets may be provided in or through a graphical userinterface and may interact with the user for the purpose of creating adate set.

In various embodiments, these and other object creation mechanisms, or acombination thereof, may be used to create various higher-order objects.

A date set may or may not be related to any other object. For example,as shown in FIG. 2A, a date set may be hard-coded by a user at client120. For example, a calendar 202 may be shown at client 120. Graphiccomponents may be rendered on a graphical user interface 200 so that theuser may select certain time values (i.e., the user selection providesthe second input that specifies one or more criteria) using calendar 202(which is the first input that specifies a time series). With calendar202 and the user selection as inputs, an object creation mechanismcreates and outputs the corresponding date set.

For a generated date set, the user may provide a token in the form of astring to this date set in a text input box 204. Subsequently, this dateset may be used in combination with other objects. In an embodiment, anyof all the entities that are involved in specifying, creating andoutputting a new date set may be stored in a machine-readable storagemedium. In addition, the new date set may also be stored or cached insuch a medium.

4.2 Index

An index indicates a collective value of one or more instruments as afunction of time over a set of time values. A collective value is anytype of aggregate value of the one or more instruments. The collectivevalue may be of a market value type such as a total monetary value ofthe one or more instruments traded at public exchanges, or of ananalytical value type such as a numeric value indicating volatility ofthe trading price for the one or more instruments, as a function of timeover the set of time values.

For the purpose of illustration only, the one or more instrumentsincluded in the index may comprise the “GOOG”, “YHOO”, and “MSFT”stocks. Hence, the index may be an aggregate market value of thesestocks, as a function of time over all trading days since January 1,2007. A market value is an aggregation of values of all assets includedin the portfolio at a corresponding time value in the set of timevalues. The market value may be measured (e.g., denominated) in areference currency such as the U.S. dollar. For example, a value of anasset such as an instrument may be a trading price of that instrument atthe closing of a particular trading day. A value of the referencecurrency may be its trading value as denominated in the referencecurrency. A value of a currency that is not the reference currency mayalso be measured in the reference currency through an exchange rate.

An index may have a start time value, for example, January 1, 2007;thus, the index does not track the collective value before the starttime value. Similarly, an index may also have an end time value; thus,the index does not track the collective value after the end time value.The start time value and/or the end time value may be explicit orimplicit.

To create an index, any of the object creation mechanisms may be used.An object creation mechanism may take a first input that specifies oneor more time series for the one or more instruments. For example, thesetime series as specified in the first input may represent trading pricesfor the “GOOG”, “YHOO”, and “MSFT” stocks on all trading days when thestocks are publicly traded. The object creation mechanism also may takea second input that specifies a date set. In some embodiments, the dateset as specified in the second input may specify a set of days for whicha collective value of the one or more instruments should be tracked. Forexample, the date set may comprise a set of last five trading days ofeach quarter since January 1, 2007. The object creation mechanism maycomprise logic to compute the collective value of the one or moreinstruments as specified in the first input over the set of time valuesas specified in the second input. The object creation mechanism maycreate and output an index in the form of a new time series. Eachnumeric value in the set of longs or doubles indicates the collectivevalue of the “GOOG”, “YHOO”, and “MSFT” stocks at a time value (e.g., aday) in the set of last five trading days of each quarter since January1, 2007.

The user may provide a token in the form of a string to name the indexso that the definition or computed value of the index can besubsequently referenced as a named object in combination with otherobjects. In an embodiment, any of all the entities that are involved inspecifying, creating and outputting a new index may be stored or cachedin a machine-readable storage medium. In addition, the definition of newindex may also be stored or cached in such a medium.

4.3 Instrument Group

An instrument group comprises one or more instruments selected from auniverse of instruments using a filter chain that is created from zeroor more set operations and one or more filter links. For example, aninstrument group may comprise all the stocks in the S&P Index (“SPX”)that are in the technology sector. Another example of instrument groupmay be all the stocks in the financial sector of the S&P Index that havelow PE ratios.

To create an instrument group, an object creation mechanism may be used.This mechanism may take a first input that specifies the zero or moreset operations. For example, a set operation of “intersection” may bespecified as the first input. The object creation mechanism also maytake a second input that specifies the one or more filter links. For thepurpose of illustration only, such a filter link may be a criterion thatany selected stock must belong to the bucket of lowest 10% among aninput set of instruments. In some embodiments, graphical user interface200 of client 120 may be used to create an instrument group, as shown inFIG. 2B. A filter view 206 may be used to represents an input set ofinstruments to which a filter link may be applied. In this example, allstocks in the financial sector of the S&P Index are used as an input setof instruments. These stocks are represented in an n-tile diagram. Thisn-tile diagram comprises n (a positively integer such as ten) buckets,each bucket comprising substantially a same number of instruments. Eachbucket represents a particular range of 10% PE ratios. Thus, if a stockis in the top 10% among all the stocks in terms of PE ratios, the stockwill be included in the bucket between 90% and 100%. Similarly, if astock is in the bottom 10% among all the stocks in terms of PE ratios,the stock will be included in the bucket between 0% and 10%. A user atclient 120 may perform a range selection 208 to select a desire range ofPE ratios. In the present example, the user selects the bottom 10% of PEratios.

The object creation mechanism may comprise logic to create a filterchain by evaluating each filter link in the filter chain, combining thefilter chains based on the set operation specified, and generates theinstrument group that comprises the one or more instruments. In thepresent example, where the filter link is created using an n-tilediagram. the object creation mechanism may create and output aninstrument group that comprises a set of instruments that are in thebottom 10% of PE ratios as indicated in FIG. 2B.

The user may provide a token in the form of a string to name theinstrument group. For example, this instrument group as illustrated inFIG. 2B may be called “low PE SPX Financials.” In some embodiments, atext input box 210 may be provided in graphical user interface 200 toaccept input of the string. Subsequently, this named instrument groupmay be used in combination with other objects by a reference to thetoken.

In an embodiment, any of all the entities that are involved inspecifying, creating and outputting a new instrument group may be storedor cached in a machine-readable storage medium. In addition, the newinstrument group may also be stored or cached in such a medium.

4.4 Portfolio

A portfolio indicates a market value of included assets as a function oftime over a set of time values. A portfolio may comprise a start timevalue from which the market value of the portfolio is to be tracked. Aportfolio may optionally comprise an end time value after which themarket value of the portfolio is no longer tracked. The set of assetsincluded in the portfolio at any given time value may comprise avariable number of instruments. The set of assets may optionally includea certain amount in various currencies (including currency equivalents).

To create a portfolio, an object creation mechanism may be used. Thismechanism may take a first input that specifies zero or more time seriesfor the zero or more instruments. For example, these time series asspecified in the first input may represent trading prices for the“GOOG”, “YHOO”, and “MSFT” stocks on all trading days when the stocksare publicly traded. In some embodiments, the object creation mechanismmay use weight factors to determine how much of each of theseinstruments is to be hold in the portfolio at each time value of a timeperiod starting from the start time value. The object creation mechanismalso takes a second input that specifies a date set. In someembodiments, the date set as specified in the second input specifies aset of time values (e.g., the preceding time period) for which a marketvalue of the portfolio should be computed. For example, the date set maycomprise a set of all trading days since January 1, 2007. The objectcreation mechanism may further take a third input that specifies the oneor more trades over the set of time values as specified in the secondinput. Each trade may specify an instrument, a buy-or-sell indication, atime of trading, and a quantity. The object creation mechanism maycomprise logic to execute, or to simulate execution of, trades asspecified in the third input and to compute the market value of theportfolio over the set of time values as specified in the second input,thereby giving rise to a new portfolio object. Any other metric may beapplied to the new portfolio object to extract information. In addition,the portfolio object may be used to create another higher-order object.In the present example, the associated set of time values to which thelong or double values are mapped is the set of time values specified inthe second input. For example, each numeric value in the set of longs ordoubles indicates a collective market value of all assets in theportfolio at a time value in the set of all trading days since January1, 2007.

The user may provide a token in the form of a string to name theportfolio so that a subsequent reference can be made to the token in anexpression that involves other objects.

In an embodiment, any of all the entities that are involved inspecifying, creating and outputting a new portfolio may be stored orcached in a machine-readable storage medium. In addition, the newportfolio may also be stored or cached in such a medium.

4.5 Strategy

A strategy, as illustrated in FIG. 2C, may be used to generate a netprofit in a time period. A net profit in a time period is a net gain orloss at the end of the time period. Here, the net profit may bedetermined by a number of trades executed within the time period andmarket conditions. A block of strategy code may be used to generate thetrades that are to be executed in connection with the strategy. In someembodiments, the net profit and the trades may be hypothetical andgenerated for the purpose of studying, validating or invalidating aparticular trading strategy.

The time period may be represented by a date set that comprises astarting time value corresponding to the beginning of the time periodand optionally an end time value corresponding to the end of the timeperiod.

In some embodiments, a strategy comprises an initial collection ofassets at the beginning of the time period. In a particular embodiment,this initial collection of assets may comprise only a starting net assetvalue (212 of FIG. 2C) in a reference currency such as the U.S. dollar.

To create a strategy, an object creation mechanism may be used. Thisobject creation mechanism may take a first input that specifies aparticular date set. Comprising a start time value and optionally an endtime value as previously described, the particular date set represents atime period where trades may be generated and executed. For example, thedate set may be all trading days from January 1, 2006 to now.Alternatively, the date set may be all trading days when the “GOOG”stock trades up.

The object creation mechanism may take a second input that specifies astatement block, which when executed generates one or more trades. Eachtrade may specify an instrument, a-buy-or-sell indication, a time oftrading, and a quantity. For the purpose of illustration, the statementblock may be displayed in a content pane 214 on graphical user interface200 in FIG. 2C. The object creation mechanism may comprise logic toexecute, or to simulate execution of, the statement block and the tradesas generated by the statement block and to compute the market value ofthe strategy over the set of time values as specified in the firstinput, thereby creating a new strategy object. Any other metric may beapplied to the new strategy object to extract information. In addition,the strategy object may be used to create another higher-order object.Furthermore, the object creation mechanism may create and output a netprofit at the end of the time period. In the present example, the objectcreation mechanism may create and output a net profit of 72,277.21 inthe reference currency of US dollar, as illustrated in 216 of FIG. 3C.

The user may provide a token in the form of a string to name thestrategy. For example, the strategy in FIG. 2C may be named as “VLDduring rising rates”, as indicated in the title bar of graphical userinterface 200 of FIG. 2C. Subsequently, this strategy may be used tocreate other higher-order objects.

In an embodiment, any of all the entities that are involved inspecifying, creating and outputting a new strategy may be stored orcached in a machine-readable storage medium. In addition, the newstrategy may also be stored or cached in such a medium.

A user may interact with graphical user interface 200 to test a tradingstrategy. For example, a statement block may be supplied (e.g., pasted)into content pane 214 of FIG. 2C and executed to create and output a netprofit at the end of the time period. Other statement blockscorresponding to various strategies of investment may also be tested bysupplying each of the other statement blocks into content pane 214 ofFIG. 2C for execution of trades. For example for the purpose ofcomparing between different trading strategies within the same timeperiod and with the same starting net asset value may be tested in thismanner.

For the purpose of illustration only, the statement block that is to beexecuted by a strategy (object) may comprise one or more rules that canbe used to determine the one or more trades, as illustrated below:

Setup code: ----------------------------------------- // A Strategybased on the idea that an instrument that  experiences large moves in //either direction tends to revert to a more normal  value. Buy theinstrument // when it crosses its lower Bollinger band; sell when it crosses its upper // Bollinger band; and always exit the position onceit  returns to its moving // average. TimeSeries series = SPX; Numberdays = 80; Number stddev = 2.0; TimeSeries lowerBollingerBand = series.bollingerSingle(days, −1*stddev); TimeSeries upperBollingerBand=  series.bollingerSingle(days, stddev); TimeSeries mean =series.ma(days); ----------------------------------------- Loop code:----------------------------------------- if(series.movesBelow(lowerBollingerBand)) {  if (numContracts(series) <=0) {   hold(series, 100, Enum.PERCENT_OF_NAV);  } } else if(series.movesAbove(upperBollingerBand)) {  if (numContracts(series) >=0) {   hold(series, −100, Enum.PERCENT_OF_NAV);  } } else if(series.movesAbove(mean) ||  series.movesBelow(mean)) {  exit(series); }

This statement block as indicated in its comment section implements atrading strategy with rules of buying 100 units in SPX if SPX movesbelow its lower Bollinger band, selling 100 units if SPX moves above itsupper Bollinger band, and exiting the position in SPX if SPX returns toits moving average.

4.6 Regression

A regression, as illustrated in FIG. 2D, may be used to performpredictions, inferences and hypothesis analyses between independent timeseries and a dependent time series in the object model.

To create a regression, an object creation mechanism may be used. Thisobject creation mechanism may take a first input that specifies one ormore first time series representing independent variables in aregression analysis. For example, the one or more first time series maybe ones that are associated with objects like “Exxon Mobil Corp”, “WTICRUDE FUTURE (1st month generic)”, and “S&P 500 INDEX” in the objectmodel, as indicated in 218 of FIG. 2D. The object creation mechanismalso may take a second input that specifies a second time seriesrepresenting a dependent variable in the regression analysis. The objectcreation mechanism may comprise logic to perform the regression analysisthat transforms the one or more first time series into a predicted timeseries and compares the predicted time series with the second timeseries, thereby creating a new regression object. This new regressionobject may be used in part by another object creation mechanism tocreate other higher-order objects. The result of the regression analysismay be presented in a content pane 222 of FIG. 2D.

The user may provide a token in the form of a string to name theregression. Subsequently, this regression may be used in combinationwith other objects through a reference to its token.

In an embodiment, any of all the entities that are involved inspecifying, creating and outputting a new regression may be stored orcached in a machine-readable storage medium. In addition, the newregression may also be stored or cached in such a medium.

5 Additional Example Higher-Order Objects

A user may define an arbitrarily complex object that is built on top ofother objects. For example, liquidity and risk models may be built as amulti-level object on top of an instrument group, a portfolio, severalindexes, a date set, etc. Similarly, an index may be built on top ofother higher-order objects.

FIG. 2E illustrates an index that is built on another higher-orderobject. The index may be built on top of one or more time series, all ofwhich belongs to a higher-order object in the form of an instrumentgroup. In other words, the instrument group, a higher-order object, isbuilt on top of three time series associated with zero-order objects(e.g., instruments, economic index, etc.), while the index uses theinstrument group as input. For the purpose of illustration only, theinstrument group may be “low PE SPX Financials”, as illustrated in FIG.2B. As shown in FIG. 2E, a collective value for the instrument group maybe tracked in the higher-order index and computed as a function of timeover a time period. This function of time may be displayed in a contentpane 224 of graphical user interface 200, as illustrated in FIG. 2E. Insome embodiments, still higher-order indexes may be built on tope ofother objects.

In some embodiments, a higher-order object may be represented as a tree.The leaf nodes of the tree are zero-order objects such as instruments.The tree may additionally and/or optionally contain non-leaf nodes. Thenon-leaf nodes are higher-order objects. In other words, a higher-orderobject may be built from building blocks. These building blocks may bezero-order or higher-order objects. For example, when an index is builtfrom an instrument group, the instrument group also may be built from acombination of other higher-order and zero-order objects.

Any of several object creation mechanisms may be selected by a user forthe purpose of creating a higher-order object. Definitions for thehigher-order objects may be generated by the object creation mechanismand saved in the system. A definition may be defined and evaluated attwo different times. The results of evaluation of a definition maychange as underlying data changes. These results may be saved in cacheor in permanent storage.

In some embodiments, types of objects in the object model may beimplemented as classes in an object-oriented language such as JAVA®,thus allowing easy incorporation of various properties of one objectinto another.

6 Dynamic Specification of Objects

In accordance with an embodiment of the present invention, an inputmechanism is provided for a user to enter expressions to the dataanalysis system for the purpose of instructing the data analysis systemto create, modify, delete, evaluate, or save various objects andcomponents in the object model. Here, the term “input mechanism”includes either a command line interaction mechanism or agraphic-user-interface based interaction mechanism, or a combination ofthe preceding two. In other embodiments, an input mechanism is not usedand objects may be specified programmatically or at runtime using othermechanisms.

An expression may comprise one or more tokens separated by delimitercharacters such as a period, parentheses, a comma, quotation marks, etc.Each token may refer to an economic index, an instrument, a metric, aninput object, an output object, a parameter, a time series, ahigher-order-object, or any higher-order object in the object model.

An expression may be evaluated with a certain order. For example, in aparticular embodiment, the expression may be evaluated according to aprecedence ordering among operators. Additionally and/or optionally,certain optimization logic may be used to determine whether any tokensin an expression can be evaluated in parallel.

Custom metrics and user-defined classes and objects can be provided to(or plugged into) the system and be immediately made available for use.In certain embodiments, a modeling language may be used to define custommetric objects. For example, a user may specify at a command lineinterface for creating a new type of object and provides to the dataanalysis system a token for this new type of object. The new type ofobject, for example, may be a new metric. However, a modeling languageis not required, and the embodiments that show use of a modelinglanguage herein are provided merely to illustrate clear examples. Thus,in one alternative, Javan objects and instance variables may be used todefine custom metric objects programmatically without using a modelinglanguage to define the objects and instance variables.

As illustrated in FIG. 2F, in an embodiment that uses a modelinglanguage, a user may type an expression “(HVOL( )+IVOL( ))/2” as 226 ofFIG. 2F to define a new custom metric. For the purpose of illustrationonly, “HVOL( )” and “IVOL( )” may be two tokens for two functions.Tokens for other constructs may also be used. The user may give a newtoken “avgvol( )” for this new metric. Subsequently, as shown in FIG.2G, the token “avgvol( )” for the new metric may be displayed as aselectable item in a dialog pane 230 of FIG. 2G. This new metric may beused together with an instrument such as “GOOG” to cause a new timeseries to be created and displayed. This new time series is produced byaveraging values from two time series as specified by “HVOL( )” and“IVOL( )”, as defined by the user in FIG. 2F.

The data analysis system may immediately make available this new type ofobject (e.g., a new function “avgvol( )”) to all users of the system.The users simply specify the token associated with the new type ofobject in subsequent expressions. As shown in FIG. 2H, time seriesrepresenting “HVOL( )” and “IVOL( )” can be displayed in a content pane232 of FIG. 2H, along with a new time series as specified by the newtoken (i.e., “avgvol( )”).

In this manner, new types of objects and new types of expressions can becontinuously added to the data analysis system, which causes the objectmodel to evolve over the time. For example, a user may continuouslydefine new hypotheses as new object types or as new instances ofexisting object types and timely test the new hypotheses in a rapidlychanging market. Evaluations of some of these hypotheses may be saved orcached along with the definitions for the hypotheses. These hypothesescan also be recalled, re-studied, and reused by way of suitable tokensat a later time.

7 Example Process Flow

FIG. 3 illustrates an example process that uses a metric to generate anoutput object based on one or more time series determined from one ormore input objects.

FIG. 3 illustrates an example process related to creating objects in theobject model. In block 302, the data analysis system 100 identifies ametric that transforms one or more time series into an output object.For example, through interacting with a user at client 120 via graphicaluser interface 200 illustrated in FIG. 2A, the data analysis system 100may receive a request from the user to create a date set. Based on therequest, the data analysis system 100 may identify an existing metricamong a plurality of metrics that output date sets. In an alternativeembodiment, the data analysis system 100 may create a new metric anewthat performs the desired transformation and identify the new metric forthe purpose of creating the date set. For the purpose of illustration,this particular metric may transform a calendar and a set of criteriainto a date set (i.e., the output object) comprising time values thatcome from the calendar and satisfy the set of criteria.

In block 304, the data analysis system 100 determines, based on one ormore input objects, the one or more time series. For example, inputobject may be the calendar and the set of criteria, a part of which isdisplayed in 202 of FIG. 2A. The calendar may be used to generate theone or more time series.

In block 306, the data analysis system 100 applies the metric using theone or more time series, thereby generating a particular value for theoutput object. For example, the metric may be used by the data analysissystem 100 to transform the time series that represents the calendarinto a date set in the form of a time series comprising time valuessatisfying the set of criteria.

In block 308, the data analysis system 100 store, in memory, one of themetric and the particular value for the output object. In someembodiments, any of other objects, time series, and parameters may alsobe stored. For example, the user may specify a name for the date set in204 of FIG. 2A and request the metric that generates the date set bestored in a physical storage device.

For the purpose of this invention, other objects including thehigher-order objects and the higher-order objects described above mayalso be created in a similar manner. For example, this example processcan be repeated to produce higher-order objects based on time seriesdetermined from higher-order objects or zero-order objects. In thismanner, higher-order objects may be built on top of higher-order objectsin the object model.

8 Extensions and Alternatives

Data analysis according to the techniques described herein is notlimited to any particular tool or any particular type of analysis. Thus,the examples of data analysis provided herein are to be regarded in anillustrative rather than a restrictive sense.

9 Example Implementation Hardware

FIG. 4 is a block diagram that illustrates a computer system 400 uponwhich an embodiment of the invention may be implemented. Computer system400 includes a bus 402 or other communication mechanism forcommunicating information, and a processor 404 coupled with bus 402 forprocessing information. Computer system 400 also includes a main memory406, such as a random access memory (RAM) or other dynamic storagedevice, coupled to bus 402 for storing information and instructions tobe executed by processor 404. Main memory 406 also may be used forstoring temporary variables or other intermediate information duringexecution of instructions to be executed by processor 404. Computersystem 400 further includes a read only memory (ROM) 408 or other staticstorage device coupled to bus 402 for storing static information andinstructions for processor 404. A storage device 410, such as a magneticdisk or optical disk, is provided and coupled to bus 402 for storinginformation and instructions.

Computer system 400 may be coupled via bus 402 to a display 412, such asa cathode ray tube (CRT), for displaying information to a computer user.An input device 414, including alphanumeric and other keys, is coupledto bus 402 for communicating information and command selections toprocessor 404. Another type of user input device is cursor control 416,such as a mouse, a trackball, or cursor direction keys for communicatingdirection information and command selections to processor 404 and forcontrolling cursor movement on display 412. This input device typicallyhas two degrees of freedom in two axes, a first axis (e.g., x) and asecond axis (e.g., y), that allows the device to specify positions in aplane.

The invention is related to the use of computer system 400 forimplementing the techniques described herein. According to oneembodiment of the invention, those techniques are performed by computersystem 400 in response to processor 404 executing one or more sequencesof one or more instructions contained in main memory 406. Suchinstructions may be read into main memory 406 from anothermachine-readable medium, such as storage device 410. Execution of thesequences of instructions contained in main memory 406 causes processor404 to perform the process steps described herein. In alternativeembodiments, hard-wired circuitry may be used in place of or incombination with software instructions to implement the invention. Thus,embodiments of the invention are not limited to any specific combinationof hardware circuitry and software.

The term “machine-readable medium” as used herein refers to any mediumthat participates in providing data that causes a machine to operate ina specific fashion. In an embodiment implemented using computer system400, various machine-readable media are involved, for example, inproviding instructions to processor 404 for execution. Such a medium maytake many forms, including but not limited to, non-volatile media,volatile media, and transmission media. Non-volatile media includes, forexample, optical or magnetic disks, such as storage device 410. Volatilemedia includes dynamic memory, such as main memory 406. Transmissionmedia includes coaxial cables, copper wire and fiber optics, includingthe wires that comprise bus 402. Transmission media can also take theform of acoustic or light waves, such as those generated during radiowave and infrared data communications. All such media must be tangibleto enable the instructions carried by the media to be detected by aphysical mechanism that reads the instructions into a machine.

Common forms of machine-readable media include, for example, a floppydisk, a flexible disk, hard disk, magnetic tape, or any other magneticmedium, a CD-ROM, any other optical medium, punch cards, paper tape, anyother physical medium with patterns of holes, a RAM, a PROM, and EPROM,a FLASH-EPROM, any other memory chip or cartridge, a carrier wave asdescribed hereinafter, or any other medium from which a computer canread.

Various forms of machine-readable media may be involved in carrying oneor more sequences of one or more instructions to processor 404 forexecution. For example, the instructions may initially be carried on amagnetic disk of a remote computer. The remote computer can load theinstructions into its dynamic memory and send the instructions over atelephone line using a modem. A modem local to computer system 400 canreceive the data on the telephone line and use an infrared transmitterto convert the data to an infrared signal. An infrared detector canreceive the data carried in the infrared signal and appropriatecircuitry can place the data on bus 402. Bus 402 carries the data tomain memory 406, from which processor 404 retrieves and executes theinstructions. The instructions received by main memory 406 mayoptionally be stored on storage device 410 either before or afterexecution by processor 404.

Computer system 400 also includes a communication interface 418 coupledto bus 402. Communication interface 418 provides a two-way datacommunication coupling to a network link 420 that is connected to alocal network 422. For example, communication interface 418 may be anintegrated services digital network (ISDN) card or a modem to provide adata communication connection to a corresponding type of telephone line.As another example, communication interface 418 may be a local areanetwork (LAN) card to provide a data communication connection to acompatible LAN. Wireless links may also be implemented. In any suchimplementation, communication interface 418 sends and receiveselectrical, electromagnetic or optical signals that carry digital datastreams representing various types of information.

Network link 420 typically provides data communication through one ormore networks to other data devices. For example, network link 420 mayprovide a connection through local network 422 to a host computer 424 orto data equipment operated by an Internet Service Provider (ISP) 426.ISP 426 in turn provides data communication services through theworldwide packet data communication network now commonly referred to asthe “Internet” 428. Local network 422 and Internet 428 both useelectrical, electromagnetic or optical signals that carry digital datastreams. The signals through the various networks and the signals onnetwork link 420 and through communication interface 418, which carrythe digital data to and from computer system 400, are exemplary forms ofcarrier waves transporting the information.

Computer system 400 can send messages and receive data, includingprogram code, through the network(s), network link 420 and communicationinterface 418. In the Internet example, a server 430 might transmit arequested code for an application program through Internet 428, ISP 426,local network 422 and communication interface 418.

The received code may be executed by processor 404 as it is received,and/or stored in storage device 410, or other non-volatile storage forlater execution. In this manner, computer system 400 may obtainapplication code in the form of a carrier wave.

In the foregoing specification, embodiments of the invention have beendescribed with reference to numerous specific details that may vary fromimplementation to implementation. Thus, the sole and exclusive indicatorof what is the invention, and is intended by the applicants to be theinvention, is the set of claims that issue from this application, in thespecific form in which such claims issue, including any subsequentcorrection. Any definitions expressly set forth herein for termscontained in such claims shall govern the meaning of such terms as usedin the claims. Hence, no limitation, element, property, feature,advantage or attribute that is not expressly recited in a claim shouldlimit the scope of such claim in any way. The specification and drawingsare, accordingly, to be regarded in an illustrative rather than arestrictive sense.

1. A computer-implemented method, comprising: creating and storing incomputer memory a programmatic object model that facilitates performingfinancial analysis and comprising a plurality of zero-order objects thatare not decomposable into other objects; wherein the object modelcomprises a universe of data items and relationships between the dataitems, and a plurality of higher-order objects that are generated basedon the zero objects; wherein the zero objects comprise a plurality oftime series objects, a plurality of metric objects, and a plurality offinancial instrument objects.
 2. The method of claim 1, wherein thehigher-order objects can be decomposed into other building blocks, andwherein the higher-order objects comprise date set objects, indexobjects, portfolio objects, strategy objects, instrument group objects,and regression objects.
 3. The method of claim 2, wherein instrumentgroup objects comprise one or more instruments selected from a universeof instruments using a filter chain; wherein index objects indicate acollective value of one or more instruments; wherein regression objectstransform one or more first time series into a predicted time series andcompares the predicted time series with a second time series; whereinportfolio objects comprise zero or more time series each of whichrepresents an instrument, a particular date set, and one or more tradesthat refer to times represented in the particular date set; whereinstrategy objects comprise a date set that represents a time period and astatement block that can be executed to determines one or more trades ofthe instrument; wherein date set objects comprises time values thatsatisfy one or more selection criteria.
 4. The method of claim 2,wherein each of the index objects comprises an instrument group object,a metric object, and a date set object.
 5. The method of claim 2,wherein each of the instrument group objects comprises a plurality offilter objects.
 6. The method of claim 5, wherein each of the filterobjects comprises a set of instrument objects and a metric object. 7.The method of claim 1, further comprising: receiving, at runtime, userinput specifying a custom metric object name and identifying an orderedor concatenated plurality of function tokens for association with thecustom metric object name; creating and storing, in the object model, acustom metric object based on the name and the tokens.
 8. Acomputer-implemented method comprising: identifying a metric thattransforms one or more time series into an output object; determining,based on one or more input objects, the one or more time series;applying the metric using the one or more time series, therebygenerating a particular value for the output object; storing, in aphysical storage device, one of the metric and the particular value forthe output object.
 9. The method of claim 8, wherein the output objectis one of a) an instrument group that comprises one or more instrumentsselected from a universe of instruments using a filter chain, b) anindex that indicates a collective value of one or more instruments, c) aregression that transforms one or more first time series into apredicted time series and compares the predicted time series with asecond time series, d) a portfolio that comprises i) zero or more timeseries each of which represents an instrument, ii) a particular dateset, and iii) one or more trades that refer to times represented in theparticular date set, e) a strategy that comprises i) a date set thatrepresents a time period and ii) a statement block that can be executedto determines one or more trades of the instrument, or f) a date setcomprising time values that satisfy one or more selection criteria. 10.The method of claim 8, wherein the output object, the one or more inputobjects, and the metric are specified in a document that specifies atree comprising a plurality of objects and a plurality of metrics. 11.The method of claim 8, wherein the first metric is a custom metricspecified as a token by a user after a data analysis system is deployed,and wherein the custom metric can be immediately accessed by referringto the token after the custom metric is dynamically loaded into the dataanalysis system as a part of computing logic of the data analysissystem.
 12. The method of claim 8, wherein the one or more time seriesinclude at least one time series whose value is not associated with aninstrument.
 13. The method of claim 8, wherein at least one of the oneor more time series is associated with an instrument in a universe ofinstruments.
 14. The method of claim 13, wherein the universe ofinstruments comprises one or more ontological relationships among allinstruments in the universe of instruments.
 15. The method of claim 8,wherein generating the particular value of the output object occurs at afirst time, wherein the metric generates another value of the outputobject at a second time different from the first time, and wherein theparticular value of the output object is different from said anothervalue of the output object.
 16. The method of claim 8, wherein themetric includes one or more input arguments whose runtime valuesinfluence runtime behaviors of the metric.
 17. A machine-readablestorage medium comprising one or more program instructions recordedthereon, which instructions, when executed by one or more processors,cause the one or more processors to perform the steps of: creating andstoring in computer memory a programmatic object model that facilitatesperforming financial analysis and comprising a plurality of zero-orderobjects that are not decomposable into other objects; wherein the objectmodel comprises a universe of data items and relationships between thedata items, and a plurality of higher-order objects that are generatedbased on the zero-order objects; wherein the zero-order objects comprisea plurality of time series objects, a plurality of metric objects, and aplurality of financial instrument objects.
 18. The medium of claim 17,wherein the higher-order objects can be decomposed into other buildingblocks, and wherein the complex objects comprise date set, index,portfolio, strategy, instrument group, and regression objects.
 19. Themedium of claim 18, wherein instrument group objects comprise one ormore instruments selected from a universe of instruments using a filterchain; wherein index objects indicate a collective value of one or moreinstruments; wherein regression objects transform one or more first timeseries into a predicted time series and compares the predicted timeseries with a second time series; wherein portfolio objects comprisezero or more time series each of which represents an instrument, aparticular date set, and one or more trades that refer to timesrepresented in the particular date set; wherein strategy objectscomprise a date set that represents a time period and a statement blockthat can be executed to determines one or more trades of the instrument;wherein date set objects comprises time values that satisfy one or moreselection criteria.
 20. The medium of claim 18, wherein each of theindex objects comprises an instrument group object, a metric object, anda date set object.
 21. The medium of claim 18, wherein each of theinstrument group objects comprises a plurality of filter objects. 22.The medium of claim 21, wherein each of the filter objects comprises aset of instrument objects and a metric object.
 23. The medium of claim17, wherein the one or more program instructions further compriseinstructions which, when executed by one or more processors, cause theone or more processors to perform: receiving, at runtime, user inputspecifying a custom metric object name and identifying an ordered orconcatenated plurality of function tokens for association with thecustom metric object name; creating and storing, in the object model, acustom metric object based on the name and the tokens.
 24. Amachine-readable storage medium comprising one or more programinstructions recorded thereon, which instructions, when executed by oneor more processors, cause the one or more processors to perform thesteps of: identifying a metric that transforms one or more time seriesinto an output object; determining, based on one or more input objects,the one or more time series; applying the metric using the one or moretime series, thereby generating a particular value for the outputobject; storing, in a physical storage device, one of the metric and theparticular value for the output object.
 25. The medium of claim 24,wherein the output object is one of a) an instrument group thatcomprises one or more instruments selected from a universe ofinstruments using a filter chain, b) an index that indicates acollective value of one or more instruments, c) a regression thattransforms one or more first time series into a predicted time seriesand compares the predicted time series with a second time series, d) aportfolio that comprises i) zero or more time series each of whichrepresents an instrument, ii) a particular date set, and iii) one ormore trades that refer to times represented in the particular date set,e) a strategy that comprises i) a date set that represents a time periodand ii) a statement block that can be executed to determines one or moretrades of the instrument, or f) a date set comprising time values thatsatisfy one or more selection criteria.
 26. The medium of claim 24,wherein the output object, the one or more input objects, and the metricare specified in a document that specifies a tree comprising a pluralityof objects and a plurality of metrics.
 27. The medium of claim 24,wherein the first metric is a custom metric specified as a token by auser after a data analysis system is deployed, and wherein the custommetric can be immediately accessed by referring to the token after thecustom metric is dynamically loaded into the data analysis system as apart of computing logic of the data analysis system.
 28. The medium ofclaim 24, wherein the one or more time series include at least one timeseries whose value is not associated with an instrument.
 29. The mediumof claim 24, wherein at least one of the one or more time series isassociated with an instrument in a universe of instruments.
 30. Themedium of claim 29, wherein the universe of instruments comprises one ormore ontological relationships among all instruments in the universe ofinstruments.
 31. The medium of claim 24, wherein generating theparticular value of the output object occurs at a first time, whereinthe metric generates another value of the output object at a second timedifferent from the first time, and wherein the particular value of theoutput object is different from said another value of the output object.32. The medium of claim 24, wherein the metric include one or more inputarguments whose runtime values influence runtime behaviors of themetric.
 33. An application server comprising: a network interface thatis coupled to a data network for receiving one or more packet flowstherefrom; a processor; and one or more stored program instructionswhich, when executed by the processor, cause the processor to carry outthe steps of: creating and storing in computer memory a programmaticobject model that facilitates performing financial analysis andcomprising a plurality of zero-order objects that are not decomposableinto other objects; wherein the object model comprises a universe ofdata items and relationships between the data items, and a plurality ofhigher-order objects that are generated based on the zero-order objects;wherein the zero-order objects comprise a plurality of time seriesobjects, a plurality of metric objects, and a plurality of financialinstrument objects.
 34. The application server of claim 33, wherein thehigher-order objects can be decomposed into other building blocks, andwherein the higher-order objects comprise date set, index, portfolio,strategy, instrument group, and regression objects.
 35. The applicationserver of claim 34, wherein instrument group objects comprise one ormore instruments selected from a universe of instruments using a filterchain; wherein index objects indicate a collective value of one or moreinstruments; wherein regression objects transform one or more first timeseries into a predicted time series and compares the predicted timeseries with a second time series; wherein portfolio objects comprisezero or more time series each of which represents an instrument, aparticular date set, and one or more trades that refer to timesrepresented in the particular date set; wherein strategy objectscomprise a date set that represents a time period and a statement blockthat can be executed to determines one or more trades of the instrument;wherein date set objects comprises time values that satisfy one or moreselection criteria.
 36. The application server of claim 34, wherein eachof the index objects comprises an instrument group object, a metricobject, and a date set object.
 37. The application server of claim 34,wherein each of the instrument group objects comprises a plurality offilter objects.
 38. The application server of claim 37, wherein each ofthe filter objects comprises a set of instrument objects and a metricobject.
 39. The application server of claim 33, wherein the one or moreprogram instructions further comprise instructions which, when executedby one or more processors, cause the one or more processors to perform:receiving, at runtime, user input specifying a custom metric object nameand identifying an ordered or concatenated plurality of function tokensfor association with the custom metric object name; creating andstoring, in the object model, a custom metric object based on the nameand the tokens.
 40. An application server comprising: a networkinterface that is coupled to a data network for receiving one or morepacket flows therefrom; a processor; and one or more stored programinstructions which, when executed by the processor, cause the processorto carry out the steps of: identifying a metric that transforms one ormore time series into an output object; determining, based on one ormore input objects, the one or more time series; applying the metricusing the one or more time series, thereby generating a particular valuefor the output object; storing, in a physical storage device, one of themetric and the particular value for the output object.
 41. Theapplication server of claim 40, wherein the output object is one of a)an instrument group that comprises one or more instruments selected froma universe of instruments using a filter chain, b) an index thatindicates a collective value of one or more instruments, c) a regressionthat transforms one or more first time series into a predicted timeseries and compares the predicted time series with a second time series,d) a portfolio that comprises i) zero or more time series each of whichrepresents an instrument, ii) a particular date set, and iii) one ormore trades that refer to times represented in the particular date set,e) a strategy that comprises i) a date set that represents a time periodand ii) a statement block that can be executed to determines one or moretrades of the instrument, or f) a date set comprising time values thatsatisfy one or more selection criteria.
 42. The application server ofclaim 40, wherein the output object, the one or more input objects, andthe metric are specified in a document that specifies a tree comprisinga plurality of objects and a plurality of metrics.
 43. The applicationserver of claim 40, wherein the first metric is a custom metricspecified as a token by a user after a data analysis system is deployed,and wherein the custom metric can be immediately accessed by referringto the token after the custom metric is dynamically loaded into the dataanalysis system as a part of computing logic of the data analysissystem.
 44. The application server of claim 40, wherein the one or moretime series include at least one time series whose value is notassociated with an instrument.
 45. The application server of claim 40,wherein at least one of the one or more time series is associated withan instrument in a universe of instruments.
 46. The application serverof claim 45, wherein the universe of instruments comprises one or moreontological relationships among all instruments in the universe ofinstruments.
 47. The application server of claim 40, wherein generatingthe particular value of the output object occurs at a first time,wherein the metric generates another value of the output object at asecond time different from the first time, and wherein the particularvalue of the output object is different from said another value of theoutput object.
 48. The application server of claim 40, wherein themetric include one or more input arguments whose runtime valuesinfluence runtime behaviors of the metric.
 49. The method of claim 2,wherein each of the regression objects comprises a set of time seriesand a date set object.
 50. The method of claim 2, wherein each of thedate set objects is associated with a metric that is configured toreceive a time series as a first input and one or more selectioncriteria as a second input and to generate one or more dates in the timeseries that are within the specified range.